package com.ourteam.workspace.dao;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;

/**
 * Template Name : DAO查询对象 Template Version : 1 Template Last Modfiy Date : Sat Aug 19 10:06:32 CST
 * 2017 Auto Generate Date : 2018-11-30 18:42:30 Warning ! This file will be overwrite when
 * regenerate !
 */
public class WorkspaceScmConfigDAOQueryBean extends BaseQueryBean {

  public WorkspaceScmConfigDAOQueryBean() {
    super();
  }

  public WorkspaceScmConfigDAOQueryBean(BaseQueryBean aQueryBean) {
    super(aQueryBean);
  }

  public WorkspaceScmConfigDAOQueryBean(BaseQueryBean aQueryBean, Map tableReplaceMap) {
    super(aQueryBean, tableReplaceMap);
  }

  public Criteria createCriteria() {

    Criteria criteria = createCriteriaInternal();
    if (oredCriteria.size() == 0) {
      oredCriteria.add(criteria);
    }
    return criteria;
  }

  protected Criteria createCriteriaInternal() {
    return new Criteria(this);
  }

  public void addIdSelectProperty() {
    addIdSelectProperty("id");
  }

  public void addIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Id, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Id, "id");
    }
  }

  public void addWorkspaceIdSelectProperty() {
    addWorkspaceIdSelectProperty("workspaceId");
  }

  public void addWorkspaceIdSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.WorkspaceId, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.WorkspaceId, "workspaceId");
    }
  }

  public void addScmTypeSelectProperty() {
    addScmTypeSelectProperty("scmType");
  }

  public void addScmTypeSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.ScmType, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.ScmType, "scmType");
    }
  }

  public void addProtocolSelectProperty() {
    addProtocolSelectProperty("protocol");
  }

  public void addProtocolSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Protocol, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Protocol, "protocol");
    }
  }

  public void addHostNameSelectProperty() {
    addHostNameSelectProperty("hostName");
  }

  public void addHostNameSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.HostName, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.HostName, "hostName");
    }
  }

  public void addHostPortSelectProperty() {
    addHostPortSelectProperty("hostPort");
  }

  public void addHostPortSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.HostPort, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.HostPort, "hostPort");
    }
  }

  public void addModuleSelectProperty() {
    addModuleSelectProperty("module");
  }

  public void addModuleSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Module, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Module, "module");
    }
  }

  public void addScmUserSelectProperty() {
    addScmUserSelectProperty("scmUser");
  }

  public void addScmUserSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.ScmUser, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.ScmUser, "scmUser");
    }
  }

  public void addScmPasswordSelectProperty() {
    addScmPasswordSelectProperty("scmPassword");
  }

  public void addScmPasswordSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.ScmPassword, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.ScmPassword, "scmPassword");
    }
  }

  public void addStatusSelectProperty() {
    addStatusSelectProperty("status");
  }

  public void addStatusSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Status, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Status, "status");
    }
  }

  public void addRemarksSelectProperty() {
    addRemarksSelectProperty("remarks");
  }

  public void addRemarksSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Remarks, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Remarks, "remarks");
    }
  }

  public void addBranchSelectProperty() {
    addBranchSelectProperty("branch");
  }

  public void addBranchSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Branch, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Branch, "branch");
    }
  }

  public void addLabelSelectProperty() {
    addLabelSelectProperty("label");
  }

  public void addLabelSelectProperty(String aAlias) {
    if (StringUtils.isNotBlank(aAlias)) {
      addSelectProperty(IWorkspaceScmConfigDAO.Label, aAlias);
    } else {
      addSelectProperty(IWorkspaceScmConfigDAO.Label, "label");
    }
  }

  public void addAllSelectProperties() {

    addIdSelectProperty();

    addWorkspaceIdSelectProperty();

    addScmTypeSelectProperty();

    addProtocolSelectProperty();

    addHostNameSelectProperty();

    addHostPortSelectProperty();

    addModuleSelectProperty();

    addScmUserSelectProperty();

    addScmPasswordSelectProperty();

    addStatusSelectProperty();

    addRemarksSelectProperty();

    addBranchSelectProperty();

    addLabelSelectProperty();
  }

  public static class Criteria extends BaseWhereCriterion<WorkspaceScmConfigDAOQueryBean> {

    protected Criteria(WorkspaceScmConfigDAOQueryBean aParentObject) {
      super(aParentObject);
    }

    public Criteria andIdIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Id + " is null");
      return this;
    }

    public Criteria andIdIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Id + " is not null");
      return this;
    }

    public Criteria andIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Id + " is not null AND " + IWorkspaceScmConfigDAO.Id + " <> ''");
      return this;
    }

    public Criteria andIdIsEmpty() {
      addCriterion(
          "(" + IWorkspaceScmConfigDAO.Id + " is null OR " + IWorkspaceScmConfigDAO.Id + " = '')");
      return this;
    }

    public Criteria andIdEqualTo(long value) {
      return andIdEqualTo(Long.valueOf(value));
    }

    public Criteria andIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.Id + " = ", value, "id");
      return this;
    }

    public Criteria andIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Id);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotEqualTo(long value) {
      return andIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.Id + " <>", value, "id");
      return this;
    }

    public Criteria andIdNotEqualToOrIsNull(long value) {
      return andIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Id + " is null OR " + IWorkspaceScmConfigDAO.Id + " <>",
          value,
          "id");
      return this;
    }

    public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Id);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThan(long value) {
      return andIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.Id + " >", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Id);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(long value) {
      return andIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.Id + " >=", value, "id");
      return this;
    }

    public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Id);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThan(long value) {
      return andIdLessThan(Long.valueOf(value));
    }

    public Criteria andIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.Id + " <", value, "id");
      return this;
    }

    public Criteria andIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Id);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(long value) {
      return andIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.Id + " <=", value, "id");
      return this;
    }

    public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Id);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdIn(long[] values) {
      if (values.length == 1) {
        return andIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Id + " in", values, "id");
        return this;
      }
    }

    public Criteria andIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Id + " not in", values, "id");
        return this;
      }
    }

    public Criteria andIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andIdEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Id + " in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andIdNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Id + " not in", Arrays.asList(values), "id");
        return this;
      }
    }

    public Criteria andIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmConfigDAO.Id + " not between", value1, value2, "id");
      return this;
    }

    public Criteria andWorkspaceIdIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " is null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " is not null");
      return this;
    }

    public Criteria andWorkspaceIdIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.WorkspaceId
              + " is not null AND "
              + IWorkspaceScmConfigDAO.WorkspaceId
              + " <> ''");
      return this;
    }

    public Criteria andWorkspaceIdIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceScmConfigDAO.WorkspaceId
              + " = '')");
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(long value) {
      return andWorkspaceIdEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " = ", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.WorkspaceId);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(long value) {
      return andWorkspaceIdNotEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " <>", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(long value) {
      return andWorkspaceIdNotEqualToOrIsNull(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdNotEqualToOrIsNull(java.lang.Long value) {

      addCriterion(
          IWorkspaceScmConfigDAO.WorkspaceId
              + " is null OR "
              + IWorkspaceScmConfigDAO.WorkspaceId
              + " <>",
          value,
          "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.WorkspaceId);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(long value) {
      return andWorkspaceIdGreaterThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " >", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.WorkspaceId);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(long value) {
      return andWorkspaceIdGreaterThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " >=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.WorkspaceId);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThan(long value) {
      return andWorkspaceIdLessThan(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThan(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " <", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.WorkspaceId);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(long value) {
      return andWorkspaceIdLessThanOrEqualTo(Long.valueOf(value));
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(java.lang.Long value) {

      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " <=", value, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.WorkspaceId);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andWorkspaceIdLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo((java.lang.Long) values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(List<java.lang.Long> values) {

      if (values.size() == 1) {
        return andWorkspaceIdEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(List<java.lang.Long> values) {
      if (values.size() == 1) {
        return andWorkspaceIdNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " not in", values, "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(java.lang.Long[] values) {

      if (values.length == 1) {
        return andWorkspaceIdEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.WorkspaceId + " in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdNotIn(java.lang.Long[] values) {
      if (values.length == 1) {
        return andWorkspaceIdNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.WorkspaceId + " not in", Arrays.asList(values), "workspaceId");
        return this;
      }
    }

    public Criteria andWorkspaceIdIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andWorkspaceIdBetween(long value1, long value2) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(IWorkspaceScmConfigDAO.WorkspaceId + " between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(long value1, long value2) {
      addCriterion(
          IWorkspaceScmConfigDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andWorkspaceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
      addCriterion(
          IWorkspaceScmConfigDAO.WorkspaceId + " not between", value1, value2, "workspaceId");
      return this;
    }

    public Criteria andScmTypeIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " is null");
      return this;
    }

    public Criteria andScmTypeIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " is not null");
      return this;
    }

    public Criteria andScmTypeIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.ScmType
              + " is not null AND "
              + IWorkspaceScmConfigDAO.ScmType
              + " <> ''");
      return this;
    }

    public Criteria andScmTypeIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.ScmType
              + " is null OR "
              + IWorkspaceScmConfigDAO.ScmType
              + " = '')");
      return this;
    }

    public Criteria andScmTypeEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmType + " = ", value, "scmType");
      return this;
    }

    public Criteria andScmTypeEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmType);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmTypeEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmType + " <>", value, "scmType");
      return this;
    }

    public Criteria andScmTypeNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.ScmType + " is null OR " + IWorkspaceScmConfigDAO.ScmType + " <>",
          value,
          "scmType");
      return this;
    }

    public Criteria andScmTypeNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmType);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmTypeNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmType + " >", value, "scmType");
      return this;
    }

    public Criteria andScmTypeGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmType);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmTypeGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmType + " >=", value, "scmType");
      return this;
    }

    public Criteria andScmTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmType);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmTypeGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmType + " <", value, "scmType");
      return this;
    }

    public Criteria andScmTypeLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmType);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmTypeLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmType + " <=", value, "scmType");
      return this;
    }

    public Criteria andScmTypeLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmType);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmTypeLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " like", buffer.toString(), "scmType");
      return this;
    }

    public Criteria andScmTypeNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " not like", buffer.toString(), "scmType");
      return this;
    }

    public Criteria andScmTypeIn(List<String> values) {

      if (values.size() == 1) {
        return andScmTypeEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmType + " in", values, "scmType");
        return this;
      }
    }

    public Criteria andScmTypeNotIn(List<String> values) {
      if (values.size() == 1) {
        return andScmTypeNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmType + " not in", values, "scmType");
        return this;
      }
    }

    public Criteria andScmTypeIn(String[] values) {

      if (values.length == 1) {
        return andScmTypeEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmType + " in", Arrays.asList(values), "scmType");
        return this;
      }
    }

    public Criteria andScmTypeNotIn(String[] values) {
      if (values.length == 1) {
        return andScmTypeNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmType + " not in", Arrays.asList(values), "scmType");
        return this;
      }
    }

    public Criteria andScmTypeIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmTypeBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " between", value1, value2, "scmType");
      return this;
    }

    public Criteria andScmTypeNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.ScmType + " not between", value1, value2, "scmType");
      return this;
    }

    public Criteria andProtocolIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " is null");
      return this;
    }

    public Criteria andProtocolIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " is not null");
      return this;
    }

    public Criteria andProtocolIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Protocol
              + " is not null AND "
              + IWorkspaceScmConfigDAO.Protocol
              + " <> ''");
      return this;
    }

    public Criteria andProtocolIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.Protocol
              + " is null OR "
              + IWorkspaceScmConfigDAO.Protocol
              + " = '')");
      return this;
    }

    public Criteria andProtocolEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Protocol + " = ", value, "protocol");
      return this;
    }

    public Criteria andProtocolEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Protocol);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andProtocolEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Protocol + " <>", value, "protocol");
      return this;
    }

    public Criteria andProtocolNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Protocol
              + " is null OR "
              + IWorkspaceScmConfigDAO.Protocol
              + " <>",
          value,
          "protocol");
      return this;
    }

    public Criteria andProtocolNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Protocol);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andProtocolNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Protocol + " >", value, "protocol");
      return this;
    }

    public Criteria andProtocolGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Protocol);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andProtocolGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Protocol + " >=", value, "protocol");
      return this;
    }

    public Criteria andProtocolGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Protocol);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andProtocolGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Protocol + " <", value, "protocol");
      return this;
    }

    public Criteria andProtocolLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Protocol);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andProtocolLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Protocol + " <=", value, "protocol");
      return this;
    }

    public Criteria andProtocolLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Protocol);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andProtocolLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " like", buffer.toString(), "protocol");
      return this;
    }

    public Criteria andProtocolNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " not like", buffer.toString(), "protocol");
      return this;
    }

    public Criteria andProtocolIn(List<String> values) {

      if (values.size() == 1) {
        return andProtocolEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Protocol + " in", values, "protocol");
        return this;
      }
    }

    public Criteria andProtocolNotIn(List<String> values) {
      if (values.size() == 1) {
        return andProtocolNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Protocol + " not in", values, "protocol");
        return this;
      }
    }

    public Criteria andProtocolIn(String[] values) {

      if (values.length == 1) {
        return andProtocolEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Protocol + " in", Arrays.asList(values), "protocol");
        return this;
      }
    }

    public Criteria andProtocolNotIn(String[] values) {
      if (values.length == 1) {
        return andProtocolNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.Protocol + " not in", Arrays.asList(values), "protocol");
        return this;
      }
    }

    public Criteria andProtocolIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andProtocolBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " between", value1, value2, "protocol");
      return this;
    }

    public Criteria andProtocolNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Protocol + " not between", value1, value2, "protocol");
      return this;
    }

    public Criteria andHostNameIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " is null");
      return this;
    }

    public Criteria andHostNameIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " is not null");
      return this;
    }

    public Criteria andHostNameIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.HostName
              + " is not null AND "
              + IWorkspaceScmConfigDAO.HostName
              + " <> ''");
      return this;
    }

    public Criteria andHostNameIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.HostName
              + " is null OR "
              + IWorkspaceScmConfigDAO.HostName
              + " = '')");
      return this;
    }

    public Criteria andHostNameEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostName + " = ", value, "hostName");
      return this;
    }

    public Criteria andHostNameEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostName);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostNameEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostName + " <>", value, "hostName");
      return this;
    }

    public Criteria andHostNameNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.HostName
              + " is null OR "
              + IWorkspaceScmConfigDAO.HostName
              + " <>",
          value,
          "hostName");
      return this;
    }

    public Criteria andHostNameNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostName);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostNameNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostName + " >", value, "hostName");
      return this;
    }

    public Criteria andHostNameGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostName);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostNameGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostName + " >=", value, "hostName");
      return this;
    }

    public Criteria andHostNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostName);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostNameGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostName + " <", value, "hostName");
      return this;
    }

    public Criteria andHostNameLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostName);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostNameLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostName + " <=", value, "hostName");
      return this;
    }

    public Criteria andHostNameLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostName);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostNameLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.HostName + " like", buffer.toString(), "hostName");
      return this;
    }

    public Criteria andHostNameNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.HostName + " not like", buffer.toString(), "hostName");
      return this;
    }

    public Criteria andHostNameIn(List<String> values) {

      if (values.size() == 1) {
        return andHostNameEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.HostName + " in", values, "hostName");
        return this;
      }
    }

    public Criteria andHostNameNotIn(List<String> values) {
      if (values.size() == 1) {
        return andHostNameNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.HostName + " not in", values, "hostName");
        return this;
      }
    }

    public Criteria andHostNameIn(String[] values) {

      if (values.length == 1) {
        return andHostNameEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.HostName + " in", Arrays.asList(values), "hostName");
        return this;
      }
    }

    public Criteria andHostNameNotIn(String[] values) {
      if (values.length == 1) {
        return andHostNameNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.HostName + " not in", Arrays.asList(values), "hostName");
        return this;
      }
    }

    public Criteria andHostNameIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostNameBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " between", value1, value2, "hostName");
      return this;
    }

    public Criteria andHostNameNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.HostName + " not between", value1, value2, "hostName");
      return this;
    }

    public Criteria andHostPortIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " is null");
      return this;
    }

    public Criteria andHostPortIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " is not null");
      return this;
    }

    public Criteria andHostPortIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.HostPort
              + " is not null AND "
              + IWorkspaceScmConfigDAO.HostPort
              + " <> ''");
      return this;
    }

    public Criteria andHostPortIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.HostPort
              + " is null OR "
              + IWorkspaceScmConfigDAO.HostPort
              + " = '')");
      return this;
    }

    public Criteria andHostPortEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostPort + " = ", value, "hostPort");
      return this;
    }

    public Criteria andHostPortEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostPort);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostPortEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostPort + " <>", value, "hostPort");
      return this;
    }

    public Criteria andHostPortNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.HostPort
              + " is null OR "
              + IWorkspaceScmConfigDAO.HostPort
              + " <>",
          value,
          "hostPort");
      return this;
    }

    public Criteria andHostPortNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostPort);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostPortNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostPort + " >", value, "hostPort");
      return this;
    }

    public Criteria andHostPortGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostPort);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostPortGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostPort + " >=", value, "hostPort");
      return this;
    }

    public Criteria andHostPortGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostPort);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostPortGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostPort + " <", value, "hostPort");
      return this;
    }

    public Criteria andHostPortLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostPort);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostPortLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.HostPort + " <=", value, "hostPort");
      return this;
    }

    public Criteria andHostPortLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.HostPort);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andHostPortLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " like", buffer.toString(), "hostPort");
      return this;
    }

    public Criteria andHostPortNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " not like", buffer.toString(), "hostPort");
      return this;
    }

    public Criteria andHostPortIn(List<String> values) {

      if (values.size() == 1) {
        return andHostPortEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.HostPort + " in", values, "hostPort");
        return this;
      }
    }

    public Criteria andHostPortNotIn(List<String> values) {
      if (values.size() == 1) {
        return andHostPortNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.HostPort + " not in", values, "hostPort");
        return this;
      }
    }

    public Criteria andHostPortIn(String[] values) {

      if (values.length == 1) {
        return andHostPortEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.HostPort + " in", Arrays.asList(values), "hostPort");
        return this;
      }
    }

    public Criteria andHostPortNotIn(String[] values) {
      if (values.length == 1) {
        return andHostPortNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.HostPort + " not in", Arrays.asList(values), "hostPort");
        return this;
      }
    }

    public Criteria andHostPortIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andHostPortBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " between", value1, value2, "hostPort");
      return this;
    }

    public Criteria andHostPortNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.HostPort + " not between", value1, value2, "hostPort");
      return this;
    }

    public Criteria andModuleIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Module + " is null");
      return this;
    }

    public Criteria andModuleIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Module + " is not null");
      return this;
    }

    public Criteria andModuleIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Module
              + " is not null AND "
              + IWorkspaceScmConfigDAO.Module
              + " <> ''");
      return this;
    }

    public Criteria andModuleIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.Module
              + " is null OR "
              + IWorkspaceScmConfigDAO.Module
              + " = '')");
      return this;
    }

    public Criteria andModuleEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Module + " = ", value, "module");
      return this;
    }

    public Criteria andModuleEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Module);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andModuleEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Module + " <>", value, "module");
      return this;
    }

    public Criteria andModuleNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Module + " is null OR " + IWorkspaceScmConfigDAO.Module + " <>",
          value,
          "module");
      return this;
    }

    public Criteria andModuleNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Module);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andModuleNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Module + " >", value, "module");
      return this;
    }

    public Criteria andModuleGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Module);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andModuleGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Module + " >=", value, "module");
      return this;
    }

    public Criteria andModuleGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Module);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andModuleGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Module + " <", value, "module");
      return this;
    }

    public Criteria andModuleLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Module);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andModuleLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Module + " <=", value, "module");
      return this;
    }

    public Criteria andModuleLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Module);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andModuleLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Module + " like", buffer.toString(), "module");
      return this;
    }

    public Criteria andModuleNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Module + " not like", buffer.toString(), "module");
      return this;
    }

    public Criteria andModuleIn(List<String> values) {

      if (values.size() == 1) {
        return andModuleEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Module + " in", values, "module");
        return this;
      }
    }

    public Criteria andModuleNotIn(List<String> values) {
      if (values.size() == 1) {
        return andModuleNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Module + " not in", values, "module");
        return this;
      }
    }

    public Criteria andModuleIn(String[] values) {

      if (values.length == 1) {
        return andModuleEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Module + " in", Arrays.asList(values), "module");
        return this;
      }
    }

    public Criteria andModuleNotIn(String[] values) {
      if (values.length == 1) {
        return andModuleNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Module + " not in", Arrays.asList(values), "module");
        return this;
      }
    }

    public Criteria andModuleIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andModuleBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " between", value1, value2, "module");
      return this;
    }

    public Criteria andModuleNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Module + " not between", value1, value2, "module");
      return this;
    }

    public Criteria andScmUserIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " is null");
      return this;
    }

    public Criteria andScmUserIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " is not null");
      return this;
    }

    public Criteria andScmUserIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.ScmUser
              + " is not null AND "
              + IWorkspaceScmConfigDAO.ScmUser
              + " <> ''");
      return this;
    }

    public Criteria andScmUserIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.ScmUser
              + " is null OR "
              + IWorkspaceScmConfigDAO.ScmUser
              + " = '')");
      return this;
    }

    public Criteria andScmUserEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " = ", value, "scmUser");
      return this;
    }

    public Criteria andScmUserEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmUser);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmUserEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " <>", value, "scmUser");
      return this;
    }

    public Criteria andScmUserNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.ScmUser + " is null OR " + IWorkspaceScmConfigDAO.ScmUser + " <>",
          value,
          "scmUser");
      return this;
    }

    public Criteria andScmUserNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmUser);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmUserNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " >", value, "scmUser");
      return this;
    }

    public Criteria andScmUserGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmUser);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmUserGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " >=", value, "scmUser");
      return this;
    }

    public Criteria andScmUserGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmUser);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmUserGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " <", value, "scmUser");
      return this;
    }

    public Criteria andScmUserLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmUser);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmUserLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " <=", value, "scmUser");
      return this;
    }

    public Criteria andScmUserLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmUser);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmUserLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " like", buffer.toString(), "scmUser");
      return this;
    }

    public Criteria andScmUserNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " not like", buffer.toString(), "scmUser");
      return this;
    }

    public Criteria andScmUserIn(List<String> values) {

      if (values.size() == 1) {
        return andScmUserEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmUser + " in", values, "scmUser");
        return this;
      }
    }

    public Criteria andScmUserNotIn(List<String> values) {
      if (values.size() == 1) {
        return andScmUserNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmUser + " not in", values, "scmUser");
        return this;
      }
    }

    public Criteria andScmUserIn(String[] values) {

      if (values.length == 1) {
        return andScmUserEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmUser + " in", Arrays.asList(values), "scmUser");
        return this;
      }
    }

    public Criteria andScmUserNotIn(String[] values) {
      if (values.length == 1) {
        return andScmUserNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmUser + " not in", Arrays.asList(values), "scmUser");
        return this;
      }
    }

    public Criteria andScmUserIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmUserBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " between", value1, value2, "scmUser");
      return this;
    }

    public Criteria andScmUserNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.ScmUser + " not between", value1, value2, "scmUser");
      return this;
    }

    public Criteria andScmPasswordIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " is null");
      return this;
    }

    public Criteria andScmPasswordIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " is not null");
      return this;
    }

    public Criteria andScmPasswordIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.ScmPassword
              + " is not null AND "
              + IWorkspaceScmConfigDAO.ScmPassword
              + " <> ''");
      return this;
    }

    public Criteria andScmPasswordIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.ScmPassword
              + " is null OR "
              + IWorkspaceScmConfigDAO.ScmPassword
              + " = '')");
      return this;
    }

    public Criteria andScmPasswordEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " = ", value, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmPassword);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmPasswordEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " <>", value, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.ScmPassword
              + " is null OR "
              + IWorkspaceScmConfigDAO.ScmPassword
              + " <>",
          value,
          "scmPassword");
      return this;
    }

    public Criteria andScmPasswordNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmPassword);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmPasswordNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " >", value, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmPassword);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmPasswordGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " >=", value, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmPassword);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmPasswordGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " <", value, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmPassword);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmPasswordLessThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " <=", value, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.ScmPassword);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andScmPasswordLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " like", buffer.toString(), "scmPassword");
      return this;
    }

    public Criteria andScmPasswordNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(
          IWorkspaceScmConfigDAO.ScmPassword + " not like", buffer.toString(), "scmPassword");
      return this;
    }

    public Criteria andScmPasswordIn(List<String> values) {

      if (values.size() == 1) {
        return andScmPasswordEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " in", values, "scmPassword");
        return this;
      }
    }

    public Criteria andScmPasswordNotIn(List<String> values) {
      if (values.size() == 1) {
        return andScmPasswordNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " not in", values, "scmPassword");
        return this;
      }
    }

    public Criteria andScmPasswordIn(String[] values) {

      if (values.length == 1) {
        return andScmPasswordEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.ScmPassword + " in", Arrays.asList(values), "scmPassword");
        return this;
      }
    }

    public Criteria andScmPasswordNotIn(String[] values) {
      if (values.length == 1) {
        return andScmPasswordNotEqualTo(values[0]);
      } else {
        addCriterion(
            IWorkspaceScmConfigDAO.ScmPassword + " not in", Arrays.asList(values), "scmPassword");
        return this;
      }
    }

    public Criteria andScmPasswordIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordNotIn(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andScmPasswordBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.ScmPassword + " between", value1, value2, "scmPassword");
      return this;
    }

    public Criteria andScmPasswordNotBetween(String value1, String value2) {
      addCriterion(
          IWorkspaceScmConfigDAO.ScmPassword + " not between", value1, value2, "scmPassword");
      return this;
    }

    public Criteria andStatusIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Status + " is null");
      return this;
    }

    public Criteria andStatusIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Status + " is not null");
      return this;
    }

    public Criteria andStatusIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Status
              + " is not null AND "
              + IWorkspaceScmConfigDAO.Status
              + " <> ''");
      return this;
    }

    public Criteria andStatusIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.Status
              + " is null OR "
              + IWorkspaceScmConfigDAO.Status
              + " = '')");
      return this;
    }

    public Criteria andStatusEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Status + " = ", value, "status");
      return this;
    }

    public Criteria andStatusEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Status);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Status + " <>", value, "status");
      return this;
    }

    public Criteria andStatusNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Status + " is null OR " + IWorkspaceScmConfigDAO.Status + " <>",
          value,
          "status");
      return this;
    }

    public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Status);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Status + " >", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Status);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Status + " >=", value, "status");
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Status);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Status + " <", value, "status");
      return this;
    }

    public Criteria andStatusLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Status);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Status + " <=", value, "status");
      return this;
    }

    public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Status);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andStatusLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Status + " like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Status + " not like", buffer.toString(), "status");
      return this;
    }

    public Criteria andStatusIn(List<String> values) {

      if (values.size() == 1) {
        return andStatusEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Status + " in", values, "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(List<String> values) {
      if (values.size() == 1) {
        return andStatusNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Status + " not in", values, "status");
        return this;
      }
    }

    public Criteria andStatusIn(String[] values) {

      if (values.length == 1) {
        return andStatusEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Status + " in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusNotIn(String[] values) {
      if (values.length == 1) {
        return andStatusNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Status + " not in", Arrays.asList(values), "status");
        return this;
      }
    }

    public Criteria andStatusIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andStatusBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " between", value1, value2, "status");
      return this;
    }

    public Criteria andStatusNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Status + " not between", value1, value2, "status");
      return this;
    }

    public Criteria andRemarksIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " is null");
      return this;
    }

    public Criteria andRemarksIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " is not null");
      return this;
    }

    public Criteria andRemarksIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Remarks
              + " is not null AND "
              + IWorkspaceScmConfigDAO.Remarks
              + " <> ''");
      return this;
    }

    public Criteria andRemarksIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.Remarks
              + " is null OR "
              + IWorkspaceScmConfigDAO.Remarks
              + " = '')");
      return this;
    }

    public Criteria andRemarksEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Remarks + " = ", value, "remarks");
      return this;
    }

    public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Remarks);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Remarks + " <>", value, "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Remarks + " is null OR " + IWorkspaceScmConfigDAO.Remarks + " <>",
          value,
          "remarks");
      return this;
    }

    public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Remarks);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Remarks + " >", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Remarks);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Remarks + " >=", value, "remarks");
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Remarks);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Remarks + " <", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Remarks);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Remarks + " <=", value, "remarks");
      return this;
    }

    public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Remarks);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andRemarksLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " not like", buffer.toString(), "remarks");
      return this;
    }

    public Criteria andRemarksIn(List<String> values) {

      if (values.size() == 1) {
        return andRemarksEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Remarks + " in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(List<String> values) {
      if (values.size() == 1) {
        return andRemarksNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Remarks + " not in", values, "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(String[] values) {

      if (values.length == 1) {
        return andRemarksEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Remarks + " in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksNotIn(String[] values) {
      if (values.length == 1) {
        return andRemarksNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Remarks + " not in", Arrays.asList(values), "remarks");
        return this;
      }
    }

    public Criteria andRemarksIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andRemarksBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " between", value1, value2, "remarks");
      return this;
    }

    public Criteria andRemarksNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Remarks + " not between", value1, value2, "remarks");
      return this;
    }

    public Criteria andBranchIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " is null");
      return this;
    }

    public Criteria andBranchIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " is not null");
      return this;
    }

    public Criteria andBranchIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Branch
              + " is not null AND "
              + IWorkspaceScmConfigDAO.Branch
              + " <> ''");
      return this;
    }

    public Criteria andBranchIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.Branch
              + " is null OR "
              + IWorkspaceScmConfigDAO.Branch
              + " = '')");
      return this;
    }

    public Criteria andBranchEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Branch + " = ", value, "branch");
      return this;
    }

    public Criteria andBranchEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Branch);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBranchEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Branch + " <>", value, "branch");
      return this;
    }

    public Criteria andBranchNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Branch + " is null OR " + IWorkspaceScmConfigDAO.Branch + " <>",
          value,
          "branch");
      return this;
    }

    public Criteria andBranchNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Branch);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBranchNotEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Branch + " >", value, "branch");
      return this;
    }

    public Criteria andBranchGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Branch);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBranchGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Branch + " >=", value, "branch");
      return this;
    }

    public Criteria andBranchGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Branch);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBranchGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Branch + " <", value, "branch");
      return this;
    }

    public Criteria andBranchLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Branch);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBranchLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Branch + " <=", value, "branch");
      return this;
    }

    public Criteria andBranchLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Branch);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andBranchLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Branch + " like", buffer.toString(), "branch");
      return this;
    }

    public Criteria andBranchNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Branch + " not like", buffer.toString(), "branch");
      return this;
    }

    public Criteria andBranchIn(List<String> values) {

      if (values.size() == 1) {
        return andBranchEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Branch + " in", values, "branch");
        return this;
      }
    }

    public Criteria andBranchNotIn(List<String> values) {
      if (values.size() == 1) {
        return andBranchNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Branch + " not in", values, "branch");
        return this;
      }
    }

    public Criteria andBranchIn(String[] values) {

      if (values.length == 1) {
        return andBranchEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Branch + " in", Arrays.asList(values), "branch");
        return this;
      }
    }

    public Criteria andBranchNotIn(String[] values) {
      if (values.length == 1) {
        return andBranchNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Branch + " not in", Arrays.asList(values), "branch");
        return this;
      }
    }

    public Criteria andBranchIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andBranchBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " between", value1, value2, "branch");
      return this;
    }

    public Criteria andBranchNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Branch + " not between", value1, value2, "branch");
      return this;
    }

    public Criteria andLabelIsNull() {
      addCriterion(IWorkspaceScmConfigDAO.Label + " is null");
      return this;
    }

    public Criteria andLabelIsNotNull() {
      addCriterion(IWorkspaceScmConfigDAO.Label + " is not null");
      return this;
    }

    public Criteria andLabelIsNotEmpty() {
      addCriterion(
          IWorkspaceScmConfigDAO.Label
              + " is not null AND "
              + IWorkspaceScmConfigDAO.Label
              + " <> ''");
      return this;
    }

    public Criteria andLabelIsEmpty() {
      addCriterion(
          "("
              + IWorkspaceScmConfigDAO.Label
              + " is null OR "
              + IWorkspaceScmConfigDAO.Label
              + " = '')");
      return this;
    }

    public Criteria andLabelEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Label + " = ", value, "label");
      return this;
    }

    public Criteria andLabelEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Label);
      str.append(" = ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLabelEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " = ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelNotEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Label + " <>", value, "label");
      return this;
    }

    public Criteria andLabelNotEqualToOrIsNull(String value) {

      addCriterion(
          IWorkspaceScmConfigDAO.Label + " is null OR " + IWorkspaceScmConfigDAO.Label + " <>",
          value,
          "label");
      return this;
    }

    public Criteria andLabelNotEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Label);
      str.append(" <> ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLabelNotEqualTo(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " <> ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelGreaterThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Label + " >", value, "label");
      return this;
    }

    public Criteria andLabelGreaterThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Label);
      str.append(" > ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLabelGreaterThan(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " > ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelGreaterThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Label + " >=", value, "label");
      return this;
    }

    public Criteria andLabelGreaterThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Label);
      str.append(" >= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLabelGreaterThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " >= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelLessThan(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Label + " <", value, "label");
      return this;
    }

    public Criteria andLabelLessThanForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Label);
      str.append(" < ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLabelLessThan(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " < ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelLessThanOrEqualTo(String value) {

      addCriterion(IWorkspaceScmConfigDAO.Label + " <=", value, "label");
      return this;
    }

    public Criteria andLabelLessThanOrEqualToForeignKey(java.lang.String key) {
      StringBuffer str = new StringBuffer(IWorkspaceScmConfigDAO.Label);
      str.append(" <= ").append(key);
      addForeignKeyCriterion(str.toString());
      return this;
    }

    public Criteria andLabelLessThanOrEqualTo(
        BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " <= ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Label + " like", buffer.toString(), "label");
      return this;
    }

    public Criteria andLabelNotLike(String value) {
      StringBuffer buffer = new StringBuffer("%");
      buffer.append(value);
      buffer.append("%");
      addCriterion(IWorkspaceScmConfigDAO.Label + " not like", buffer.toString(), "label");
      return this;
    }

    public Criteria andLabelIn(List<String> values) {

      if (values.size() == 1) {
        return andLabelEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Label + " in", values, "label");
        return this;
      }
    }

    public Criteria andLabelNotIn(List<String> values) {
      if (values.size() == 1) {
        return andLabelNotEqualTo(values.get(0));
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Label + " not in", values, "label");
        return this;
      }
    }

    public Criteria andLabelIn(String[] values) {

      if (values.length == 1) {
        return andLabelEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Label + " in", Arrays.asList(values), "label");
        return this;
      }
    }

    public Criteria andLabelNotIn(String[] values) {
      if (values.length == 1) {
        return andLabelNotEqualTo(values[0]);
      } else {
        addCriterion(IWorkspaceScmConfigDAO.Label + " not in", Arrays.asList(values), "label");
        return this;
      }
    }

    public Criteria andLabelIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelNotIn(BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " not in ", subQueryBean, dao);
      return this;
    }

    public Criteria andLabelBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " between", value1, value2, "label");
      return this;
    }

    public Criteria andLabelNotBetween(String value1, String value2) {
      addCriterion(IWorkspaceScmConfigDAO.Label + " not between", value1, value2, "label");
      return this;
    }
  }
}
